Unit Tests

Index

Overview
Unit Tests Are the Key
Simple Definition
Test Case
Setting Up Input
Test Methods (Testing Output)
Step-By-Step Code Examples
Adding a Test Case
Adding Tests
Test First
References

Unit testing is the most important part of software engineering.

It's not too hard to write some code. But solving a complex problem correctly for a variety if inputs is challenging.
And if you are writing code to be graded, you can "grade" your own code before submitting and correct as needed to assure a desired grade.

That is where unit testing comes in. As coders, we let "test code" do the hard work of validating software. Otherwise, it's an effectively impossible (manual) task for complex problems.

Unit Tests Are the Key

Unit tests are the key to our success in coding.

This is Why:

Almost all code requires "tinkering"
The tests tell us when our tinkering has produced a correct solution
Without unit tests, we as coders end up going in solution loops (known from experience)

Simple Definition

The essence of unit testing is this:

Execute a method(s) on an object and assert that the actual result equals the expected result:

Test Case

A test case is simply a "case" (group) of tests.

For one case, we capture a given input condition.

For rectangle objects, we'll code two cases:

Test Case	Description
RectangleTestCase	Construct rectangle with inputs width=10 and height=5
RectangleEdgeTestCase	Construct rectangle with no inputs (for this case, we expect defaults of width=0 and height=0)

Test case classes may be given any name (coder's choice).

Setting Up Input

There are different ways to setup input.

We'll look at a nice, simple (and suggested) approach.

beforeEach

We only need one setup method. It is called "beforeEach".

As you can see, we construct our test unit here and assign to the "unit" ivar.

Then, the "test methods" have access to this "unit" ivar.

beforeEach() {
	super.beforeEach();
	this.unit = new Rectangle(10, 5);
}

Test Methods (Testing Output)

Test methods can be given any name, but must begin with "test".

You will have a set of test methods in each test case class.

Our test examples will show a common test pattern. We assert that an actual result equals an expected result.

testGetArea

The first argument "50" is the expected result
The second argument "this.unit.getArea()" produces the actual result from the test unit object

testGetArea() {
	this.assertEquals(150, 2this.unit.getArea());
}

testGetPerimeter

The first argument "30" is the expected result
The second argument "this.unit.getPerimeter()" produces the actual result from the test unit object

testGetPerimeter() {
	this.assertEquals(130, 2this.unit.getPerimeter());
}

Step-By-Step Code Examples

We'll learn by example. We'll use a simple rectangle object to help with the learning curve.

First we'll get familiar with what we are testing:

Rectangle

And here are two test cases:

Here is the complete project source code for the examples.

Adding a Test Case

Adding tests to a test case is easy:

Copy an existing test case file
Rename the new file as desired
Open the new file
Rename the test case as desired
Search for "housekeeping" and make those two minor updates
Update the code in "beforeEach" for your specific case
Delete the copied test methods and add your own
Add a "script" line in "unit-test.html" for the new file name.

See the guide examples and sections above for more

Adding Tests

Adding tests to a test case is easy:

Open the test case file in an editor
Copy an existing test method
Rename the copy as desired (make sure the method names begins with "test")
Code in your new test
That's it!

Test First

It might seem odd writing tests before solving a problem, but it has two advantages:

Gives us ideas for our solution
Gives us instant status of how we are doing, once we start coding

References

JavaScript Guide (Chapter 306 - UnitTests)

< Unit Tests >

Search Site Home Back To Top